﻿#region License

// Copyright © 2004 - 2010 All Right Reserved, Derek Goslin
// 
// 1. Definitions
// The terms "reproduce," "reproduction," "derivative works," and "distribution" have the same meaning here as under U.S. copyright law.
// A "contribution" is the original software, or any additions or changes to the software.
// A "contributor" is any person that distributes its contribution under this license.
// "Licensed patents" are a contributor's patent claims that read directly on its contribution.
// 
// 2. Grant of Rights
// (A) Copyright Grant- Subject to the terms of this license, including the license
//     conditions and limitations in section 3, each contributor grants you a non-exclusive,
//     worldwide, royalty-free copyright license to reproduce its contribution, prepare derivative 
//     works of its contribution, and distribute its contribution or any derivative works that you create.
// (B) Patent Grant- Subject to the terms of this license, including the license conditions and limitations
//     in section 3, each contributor grants you a non-exclusive, worldwide, royalty-free license under its
//     licensed patents to make, have made, use, sell, offer for sale, import, and/or otherwise dispose of
//     its contribution in the software or derivative works of the contribution in the software.
// 
// 3. Conditions and Limitations
// (A) Reciprocal Grants- For any file you distribute that contains code from the software (in source code or binary format), 
//     you must provide recipients the source code to that file along with a copy of this license, which license will govern that file. 
//     You may license other files that are entirely your own work and do not contain code from the software under any terms you choose.
// (B) No Trademark License- This license does not grant you rights to use any contributors' name, logo, or trademarks.
// (C) If you bring a patent claim against any contributor over patents that you claim are infringed by the software,
//     your patent license from such contributor to the software ends automatically.
// (D) If you distribute any portion of the software, you must retain all copyright, patent, trademark,
//     and attribution notices that are present in the software.
// (E) If you distribute any portion of the software in source code form, you may do so only under this license by including a complete copy 
//     of this license with your distribution. If you distribute any portion of the software in compiled or object code form, you may only do 
//     so under a license that complies with this license.
// (F) The software is licensed "as-is." You bear the risk of using it. The contributors give no express warranties, guarantees or conditions.
//    You may have additional consumer rights under your local laws which this license cannot change. To the extent permitted under your
//    local laws, the contributors exclude the implied warranties of merchantability, fitness for a particular purpose and non-infringement.

#endregion

using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using DnEcuDiag.Devices.Enums;
using DnEcuDiag.Devices.Interfaces;
using DnEcuDiag.Devices.Responses;

namespace DnEcuDiag.Tests
{
    internal class KwpTestDevice : IDevice
    {
        public byte[] Faultcodeinfo;
        public byte[] FaultcodeList;
        public byte[] LocalidentifierData;

        #region IDevice Members

        public Response SendCommandWithInit(byte ecuId, byte testerId, byte[] commandToSend, DeviceInitType type)
        {
            if (commandToSend.Length == 1)
            {
                if (commandToSend[0] == 0x81)
                    return new Kwp2000Response(new byte[] { 0xC1, 0x55, 0xAA });
            }

            return null;
        }

        public int EcuResponseTimeout
        {
            get { return 0; }
            set { }
        }

        public int EcuResponseInterbyteTimeout
        {
            get { return 0; }
            set { }
        }

        public void Close()
        {
        }

        public byte[] KeyBytes
        {
            get { return null; }
        }

        public Response SendCommand(byte ecuId, byte testerId, byte[] commandToSend)
        {
            if (commandToSend.Length == 1)
            {
                if (commandToSend[0] == 0x3E)
                    return new Kwp2000Response(new byte[] { 0x7E });
            }

            if (commandToSend.Length == 2)
            {
                if (commandToSend[0] == 0x21)
                {
                    if (commandToSend[1] == 0x80)
                    {
                        var ident = new byte[63];

                        ident[0] = 61;
                        ident[1] = commandToSend[1];
                        int i, j, k, l = 0;
                        var b = (byte)'0';

                        for (i = 2; i < 10 + 2; i++)
                        {
                            ident[i] = b++;
                        }

                        ident[i++] = 0x20;
                        b = (byte)'0';

                        for (j = i; j < 10 + i; j++)
                        {
                            ident[j] = b++;
                        }

                        ident[j++] = 0x20;
                        ident[j++] = 0x10;
                        b = (byte)'0';

                        for (k = j; k < 10 + j; k++)
                        {
                            ident[k] = b++;
                        }

                        ident[k++] = 0x20;
                        ident[k++] = 0x55;
                        ident[k++] = 0xAA;

                        b = (byte)'0';

                        for (l = k; l < 5 + k; l++)
                        {
                            ident[l] = b++;
                        }

                        ident[l++] = 0x20;
                        ident[l++] = 0x55;
                        ident[l++] = 0xAA;
                        ident[l++] = 0x55;
                        ident[l++] = 0xAA;
                        ident[l++] = 0x55;

                        l += 10;

                        ident[l++] = 0x19;
                        ident[l++] = 0x97;
                        ident[l++] = 0x03;
                        ident[l++] = 0x31;

                        return new Kwp2000Response(ident);
                    }

                    return new Kwp2000Response(LocalidentifierData);
                }

                if (commandToSend[0] == 0x10)
                    return new Kwp2000Response(new byte[] { 0x50, commandToSend[1] });

                if (commandToSend[0] == 0x83)
                    return new Kwp2000Response(new byte[] { 0xC3, commandToSend[1], 0, 0, 0, 0, 0 });

                if (commandToSend[0] == 0x31)
                    return new Kwp2000Response(new byte[] { 0x71, commandToSend[1] });

                if (commandToSend[0] == 0x33)
                    return new Kwp2000Response(LocalidentifierData);
            }
            if (commandToSend.Length == 4)
            {
                if (commandToSend[0] == 0x18)
                    return new Kwp2000Response(FaultcodeList);

                if ((commandToSend[0] == 0x21) & (commandToSend[1] == 0x10))
                {
                    return new Kwp2000Response(Faultcodeinfo);
                }
                if (commandToSend[0] == 0x31)
                {
                    return new Kwp2000Response(new byte[] { 0x71, commandToSend[1] });
                }
            }
            if (commandToSend.Length == 3)
            {
                if (commandToSend[0] == 0x17)
                    return new Kwp2000Response(Faultcodeinfo);
            }
            if (commandToSend.Length == 7)
            {
                if (commandToSend[0] == 0x83)
                    return new Kwp2000Response(new byte[] { 0xC3, commandToSend[1], 0, 0, 0, 0, 0 });
            }

            return null;
        }

        public int RequestInterByteTime
        {
            get { return 0; }
            set { }
        }

        public bool EnableTrace
        {
            get { throw new Exception("The method or operation is not implemented."); }
            set { throw new Exception("The method or operation is not implemented."); }
        }

        public ReadOnlyCollection<byte[]> IdentificationData
        {
            get { return new List<byte[]>().AsReadOnly(); }
        }

        public void Dispose()
        {
        }

        #endregion
    }
}